﻿//2024-1-7 Sunday 17:55:53
//第12讲：深⼊理解指针(2)
//⽬录
//1. 数组名的理解
//2. 使⽤指针访问数组
//3. ⼀维数组传参的本质
//4. 冒泡排序
//5. ⼆级指针
//6. 指针数组
//7. 指针数组模拟⼆维数组

//5. ⼆级指针
//#include <stdio.h>
//
//int main()
//{
//	int a = 10;
//	int* pa = &a;
//	int* ppa = &pa;
//
//	int b = 20;
//	*ppa = &b;//等价于pa = &b;
//
//	**ppa = 30;//严重性	代码	说明	项目	文件	行	禁止显示状态
//	//错误(活动)	E0075	"*" 的操作数必须是指针，但它具有类型 "int"	try_8_12	F : \whoami\C\pg\code\my_code\try_8_12\try_8_12\try.c	23
//
//	//等价于*pa = 30;
//	//等价于a = 30;
//
//
//	return 0;
//}


//第12讲：深⼊理解指针(2)
//⽬录
//1. 数组名的理解
//2. 使⽤指针访问数组
//3. ⼀维数组传参的本质
//4. 冒泡排序
//5. ⼆级指针
//6. 指针数组
//7. 指针数组模拟⼆维数组


//6. 指针数组
//int arr[5];//整型数组
//char arr[5];//字符数组
//int* arr[5];//指针数组


//第12讲：深⼊理解指针(2)
//⽬录
//1. 数组名的理解
//2. 使⽤指针访问数组
//3. ⼀维数组传参的本质
//4. 冒泡排序
//5. ⼆级指针
//6. 指针数组
//7. 指针数组模拟⼆维数组

//7. 指针数组模拟⼆维数组
//#include <stdio.h>
//
//int main()
//{
//	int arr1[] = { 1, 2, 3, 4, 5 };
//	int arr2[] = { 2, 3, 4, 5, 6 };
//	//数组名是数组首元素地址，类型是int*，就可以存放在parr数组中
//
//	int* parr[] = { arr1, arr2 };
//
//	int i = 0;
//
//	for (i = 0; i < 2; i++)
//	{
//		int j = 0;
//		
//		for (j = 0; j < 5; j++)
//		{
//			printf("%d", parr[i][j]);
//		}
//
//		printf("\n");
//	}
//
//	return 0;
//}


//2024-1-8 Monday 13:30:03
//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表

//1. 字符指针变量
//int* p//整型指针类型
//char* p//字符指针类型


//int main()
//{
//	char ch = 'w';
//	char* pc = &ch;
//	*pc = 'v';
//
//	return 0;
//}


//#include <stdio.h>
//
//int main()
//{
//	const char* ptr = "hello";//这里是把一个字符串放到ptr指针变量里了吗？不希望指向的对象被改，因为是字符串常量
//	printf("%s\n", ptr);//既然放的是首字符地址，为什么整个字符串都给打印出来了呢？不应该只打印H的地址吗
//
//	return 0;
//}


//2024-1-9 tuesday 13:43:43
//#include <stdio.h>
//
//int main()
//{
//	char str1[] = "hello";
//	char str2[] = "hello";
//
//	const char* str3 = "hello";
//	const char* str4 = "hello";
//
//	if (str1 == str2)
//	{
//		printf("str1 and str2 are same\n");
//	}
//	else
//	{
//		printf("str1 and str2 are not same\n");
//	}
//
//	if (str3 == str4)
//	{
//		printf("str3 and str4 are same\n");
//	}
//	else
//	{
//		printf("str3 and str4 are not same\n");
//	}
//	
//	return 0;
//}


//2024-1-10 Wednesday 13:29:31
//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表

//2. 数组指针变量
//int* p1[10];//error，p1[10]再解引用
//int(*p2)[10];


//2.2 数组指针变量怎么初始化
//int main()
//{
//	int arr[10] = { 0 };
//	int(*p)[10] = &arr;
//	
//	return 0;
//}


//2024-1-11 Thursday 13:30:09
//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表

//3. ⼆维数组传参的本质
//#include <stdio.h>
//
//void test(int arr[][5], int r, int c)
//{
//	int i = 0;
//
//	for (i = 0; i < r; i++)
//	{
//		int j = 0;
//
//		for (j = 0; j < c; j++)
//		{
//			printf("%d ", arr[i][j]);
//		}
//
//		printf("\n");
//	}
//}
//
//int main()
//{
//	int arr[][5] = { { 1, 2, 3, 4, 5 }, { 2, 3, 4, 5, 6 }, { 3, 4, 5, 6, 7 } ,};
//
//	test(arr, 3, 5);
//
//
//	return 0;
//}


//2024-1-13 Saturday 19:40:02
//利用指针的方式
//#include <stdio.h>
//
//void test(int(*p)[5], int r, int c)
//{
//	int i = 0;
//
//	for (i = 0; i < r; i++)
//	{
//		int j = 0;
//
//		for (j = 0; j < c; j++)
//		{
//			printf("%d ", *(*(p + i) + j));
//		}
//
//		printf("\n");
//	}
//}
//
//int main()
//{
//	int arr[3][5] = { { 1, 2, 3, 4, 5 } , { 2, 3, 4, 5, 6, },  { 3, 4, 5, 6, 7,} };
//	test(arr, 3, 5);
//
//	return 0;
//}
 

//2024-1-15 Monday 13:36:15
//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表

//4. 函数指针变量
//4.1 函数指针变量的创建
//#include <stdio.h>
//
//void test()
//{
//	printf("hello\n");
//}
//
//int main()
//{
//	printf("test : %p\n", test);
//	printf("&test: %p\n", &test);
//
//	return 0;
//}


//2024-1-17 Wednesday 13:25:09
//#include <stdio.h>
//
//void test()
//{
//	printf("hello\n");
//}
//
//int Add(int x, int y)
//{
//	return x + y;
//}
//
//int main()
//{
//	void (*pf1)() = test;
//	void (*pf2)() = &test;
//
//	int (*pf3)(int, int) = Add;//有参数写参数
//	int (*pf4)(int x, int y) = &Add;//x 和 y 写上或着省略都是可以的，即：形参名可写可不写，我觉得还是不写吧
//	//pf4 的函数指针变量的类型是 int (*)(int, int)，省略函数名就是函数指针的类型，当然这也可以省略形参名
//
//	printf("%p\n", pf1);
//	printf("%p\n", pf2);
//
//	printf("%p\n", pf3);
//	printf("%p\n", pf4);
//
//
//	printf("%p\n", *pf1);
//	printf("%p\n", *pf2);
//
//	printf("%p\n", *pf3);
//	printf("%p\n", *pf4);
//	//对他们（函数名）解引用为什么得到的还是地址？
//
//	return 0;
//}

//2024-1-18 Thursday 13:06:13
//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表

//4.2 函数指针变量的使⽤
//#include <stdio.h>
//
//int Add(int x, int y)
//{
//	return x + y;
//}
//
//int main()
//{
//	int (*pf)(int, int) = Add;
//	//通过地址去调
//	if (*pf == Add)
//	printf("%d\n", (*pf)(2, 3));
//	
//	if (pf == Add)
//	printf("%d\n", pf(3, 5));//为什么不解引用也行，pf存进去的不是地址吗？或者说难道pf == Add，操作了一番确实是，
//	//既然这样pf也相当于函数名咯
//	return 0;
//}


//4.3 两段有趣的代码
//(*(void (*)())0)();
//  (void(*)())       //函数指针类型
//  ((void(*)())0)    //将零转化为函数指针类型
//  (*((void(*)())0)) //再放颗星，说明是指针变量
//  (*((void (*)())0)()//指向的函数

//为什么没有写类型呢？??


//void (*signal(int, void(*)(int)))(int);
//void                             (int);//函数指针变量
//void (*signal                   )(int);//说明是指针变量
//void (*signal(int, void(*)(int)))(int);//指向的是函数，两个形参为：整型，函数指针类型


//4.3.1 typedef关键字
//typedef unsigned int unit;//将unsigned int重命名为unit
//typedef int* ptr_t;
//
////新的类型名必须放在*的右边
//typedef int(*parr_t)[5];
//typedef void(*pfun_t)(int);
//
////那么要简化代码2，可以这样写
//typedef void(*pfun_t)(int);
//pfun_t signal(int, pfun_t);//??????
//void(*)(int) signal(int, void(*)(int))//???


//2024-1-21 Sunday 10:44:17
//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表

//5. 函数指针数组
//int* arr[10];//指针数组
//数组的每个元素是int*

//int(*)()parr[10]//error
//我的理解

//int (*parr1[3])();//parr1先和[]结合，说明parr1是数组，数组的内容是：int(*)()类型的函数指针
//我的理解：放在*里面放数组

//int* parr2[3]();//error
//int (*)() parr3[3];//error


//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表

//6. 转移表 - 函数指针数组的⽤途
//计算器的⼀般实现
//#include <stdio.h>
//#pragma warning(disable : 4996)
//
//void menu()
//{
//	printf("\n");
//	printf("*************************\n");
//	printf("***      0. Exit      ***\n");
//	printf("*************************\n");
//	printf("*** 1. Add *** 2. Sub ***\n");
//	printf("*** 3. Mul *** 4. Div ***\n");
//	printf("*************************\n");
//}
//
//int Add(int x, int y)
//{
//	return x + y;
//}
//
//int Sub(int x, int y)
//{
//	return x - y;
//}
//
//int Mul(int x, int y)
//{
//	return x * y;
//}
//
//int Div(int x, int y)
//{
//	return x / y;
//}
//
//int main()
//{
//	int input = 0;
//	int x = 0;
//	int y = 0;//两个操作数
//	int ret = 0;//结果
//
//	do
//	{
//		menu();
//		printf("请选择：");
//		scanf("%d", &input);
//
//		switch (input)
//		{
//
//			//加法运算
//		case 1:
//			printf("第一个整数:");
//			scanf("%d", &x);
//			printf("第二个整数：");
//			scanf("%d", &y);
//
//			ret = Add(x, y);
//			printf("%d + %d = %d\n", x, y, ret);
//			break;
//			//减法运算
//		case 2:
//			printf("第一个整数:");
//			scanf("%d", &x);
//			printf("第二个整数：");
//			scanf("%d", &y);
//
//			ret = Sub(x, y);
//			printf("%d - %d = %d\n", x, y, ret);
//			break;
//			//乘法运算
//		case 3:
//			printf("第一个整数:");
//			scanf("%d", &x);
//			printf("第二个整数：");
//			scanf("%d", &y);
//
//			ret = Mul(x, y);
//			printf("%d * %d = %d\n", x, y, ret);
//			break;
//			//除法运算
//		case 4:
//			printf("第一个整数:");
//			scanf("%d", &x);
//			printf("第二个整数：");
//			scanf("%d", &y);
//
//			ret = Div(x, y);
//			printf("%d / %d = %d\n", x, y, ret);
//
//			break;
//			//退出游戏
//		case 0:
//			printf("退出程序\n");
//			break;
//			//非法选择
//		default:
//			printf("非法选择，请重新选择\n");
//			break;
//		} 
//
//	} while (input);
//
//
//
//	return 0;
//}


//使⽤函数指针数组的实现：
//#include <stdio.h>
//#pragma warning(disable : 4996)
//
//void menu()
//{
//	printf("\n");
//	printf("*************************\n");
//	printf("***      0. Exit      ***\n");
//	printf("*************************\n");
//	printf("*** 1. Add *** 2. Sub ***\n");
//	printf("*** 3. Mul *** 4. Div ***\n");
//	printf("*************************\n");
//}
//
//int Add(int a, int b)
//{
//	return a + b;
//}
//int Sub(int a, int b)
//{
//	return a - b;
//}
//int Mul(int a, int b)
//{
//	return a * b;
//}
//int Div(int a, int b)
//{
//	return a / b;
//}
//
//int main()
//{
//	int input = 0;
//	int x = 0;
//	int y = 0;
//	int ret = 0;
//	
//	do
//	{
//		menu();
//		printf("请选择：");
//		scanf("%d", &input);
//
//		int(*p[5])(int x, int y) = { 0, Add, Sub, Mul, Div };//转移表
//		//(int x, int y)???
//
//		if ((input <= 4 && input >= 1))
//		{
//			printf("请输入操作数：");
//			scanf("%d %d", &x, &y);
//			//ret = (*p[input])(x, y);//根据数组下标
//			ret = p[input](x, y);
//			//???
//
//			printf("ret = %d\n", ret);
//		}
//		else if (0 == input)
//		{
//			printf("退出计算器\n");
//		}
//		else
//		{
//			printf("非法选择，请重新选择");
//		}
//
//	} while (input);
//	
//	return 0;
//}





































  

















//2024-1-14 Sunday 10:18:32
//test.c
//第12讲：深⼊理解指针(2)
//目录
//1. 数组名的理解
//2. 使⽤指针访问数组
//3. ⼀维数组传参的本质
//4. 冒泡排序
//5. ⼆级指针
//6. 指针数组
//7. 指针数组模拟⼆维数组

//5. ⼆级指针
//#include <stdio.h>
//
//int main()
//{
//	int a = 10;
//	int* p = &a;//p是一级指针
//
//	//a是整型变量，占用4个字节的空间(无论x64还是x86)，a是有自己的地址的，&a拿到的就是a所占4个字节的第一个字节的地址
//	//printf("%zd\n", sizeof(int));
//	//printf("%zd\n", sizeof (a));
//	////printf("%zd\n", sizeof int);//error
//	//printf("%zd\n", sizeof a);
//
//	//p是指针变量，占用4/8个字节的空间，p也是有自己的地址的，&p就拿到了p的地址
//
//	int** pp = &p;
//
//	printf("%d\n", **pp);//10
//
//	//pp也是指针变量，pp是二级指针变量
//
//	int*** ppp = &pp;//ppp是三级指针变量
//
//	//...
//
//	return 0;
//}


//6. 指针数组
//#include <stdio.h>
//
//int main()
//{
//	int a = 1;
//	int b = 2;
//	int c = 3;
//	int d = 4;
//	int e = 5;
//
//	int* parr[5] = { &a, &b, &c, &d, &e };
//
//	int i = 0;
//
//	for (i = 0; i < 5; i++)
//	{
//		printf("%d\n", *(parr[i]));
//	}
//
//	return 0;
//}


//7. 指针数组模拟⼆维数组
//#include <stdio.h>
//
//int main()
//{
//	int arr1[] = { 1, 2, 3, 4, 5 };
//	int arr2[] = { 2, 3, 4, 5, 6 };
//	int arr3[] = { 3, 4, 5, 6, 7 };
//
//	int* parr[3] = { arr1, arr2, arr3 };
//
//	int i = 0;
//
//	for (i = 0; i < 3; i++)
//	{
//		int j = 0;
//
//		for (j = 0; j < 5; j++)
//		{
//			printf("%d ", parr[i][j]);
//			//printf("%d ", *(*(parr + i) + j));
//			//parr[i] == *(parr + i)
//			//parr[i][j] == *(*(parr+i)+j)
//			//为什么啊？为什么要解引用2次，因为第一次解引用找到的是数组parr中，arr1这个元素，再让这个元素解引用就找到了数组arr1中的1
//                                          //第一次解引用找到的是parr[0]，和j无关...
//		}
//
//		printf("\n");
//	}
//
//	return 0;
//}


//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表


//1. 字符指针变量
//#include <stdio.h>
//
//int main()
//{
//	/*
//	int a = 10;
//	int* p = &a;//整型指针变量
//
//	char ch = 'a';
//	char* pc = &ch;//pc就是字符指针变量
//	*/
//	//字符指针变量是用来存放字符的地址的
//
//	//指针变量是用来存放指定类型的地址的
//
//	const char* p = "abcdefghi";//不是将abcdefghi\0字符串存放到p中，而是将首字符a地址存储在p中
//	//不希望这个p变量指向的字符被改变，所以加上const
//	//"abcdefghi"是一个常量字符串，是不能被修改的，变量才能被修改，如下：
//	//int b = 10;
//	//b = 20;
//	//
//	//*p = 'w';//error
//	//[abcdefghi\0]
//	//b = 2 + 3
//	//表达式都有2个属性：值属性，类型属性
//	//2 + 3 值是5
//	//2 + 3 int
//
//	printf("%c\n", *p);//打印首字符a
//	printf("%s\n", p);//p是a的首地址，因为字符串是连续的，所以能直接依次打印全部字符串//为什么啊？
//
//
//	return 0;
//}


//#include <stdio.h>
//
//int main()
//{
//	char arr1[] = "hello";
//	char arr2[] = "hello";
//
//	const char* str3 = "hello";
//	const char* str4 = "hello";
//
//	if (arr1 == arr2)
//	{
//		printf("arr1 and arr2 are same\n");
//	}
//	else
//	{
//		printf("arr1 and arr2 are no same\n");
//	}
//
//	if (str3 == str4)
//	{
//		printf("str3 and str4 are same\n");
//	}
//	else
//	{
//		printf("str3 and str4 are no same\n");
//	}
//
//	return 0;
//}


//倒计时60s
//#include <stdio.h>
//#include <windows.h>
//#include <stdlib.h>
//
//int main()
//{
//	int s = 60;
//
//	while (s < 61)
//	{
//		printf("%d\n", s--);
//		Sleep(1000);
//		system("cls");
//	}
//
//	return 0;
//}


//2024-1-19 Friday 12:38:29
//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表

//2. 数组指针变量
//int main()
//{
//	int arr[6];
//	int* p = arr;       //数组首元素地址
//
//	int(*ptr)[6] = &arr;//数组的地址
//	//ptr是数组指针
//
//	char* ch[8];
//	char* (*ptr2)[8] = &ch;
//	//ptr2是数组指针
//
//	return 0;
//}


//#include <stdio.h>
//
//int main()
//{
//	int arr[10] = { 0 };
//	//arr;//数组首元素的地址 - int*
//	//&arr;//数组的地址     -int(*)[10]
//	int(*p)[10] = &arr;
//	int* p2 = &arr;//数组的地址存为什么也可以存进去？
//	//但是存进去的实质是数组首元素的地址
//
//	printf("%p\n", p);
//	printf("%p\n", p2);
//
//	printf("%p\n", p + 1); //跳过1个数组
//	printf("%p\n", p2 + 1);//跳过1个元素
//
//	return 0;
//}


//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表

//3. ⼆维数组传参的本质
//通过指针遍历数组 - 利用数组首元素的地址
//#include <stdio.h>
//
//int main()
//{
//	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int* p = arr;
//	int i = 0;
//
//	for (i = 0; i < sz; i++)
//	{
//		printf("%d ", *(arr + i));
//	}
//	printf("\n");
//
//	return 0;
//}


//通过指针遍历数组 - 利用数组的地址
//#include <stdio.h>
//
//int main()
//{
//	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//	int(*p)[10] = &arr;
//
//	int i = 0;
//
//	for (i = 0; i < 10; i++)
//	{
//		//(*p)
//		//(*&arr)
//		//arr
//		//printf("%d\n", (*p)[i]);//首先*p找到的是数组的地址，看作是数组首元素的地址，即数组名，数组名[]访问数组；
//		//printf("%d\n", (*(*&arr) + i));
//		//printf("%d ", *((*p) + i));
//	}
//	//就这样
//	return 0;
//}


//打印二维数组
//#include <stdio.h>

//void test(int arr[3][5], int r, int c)
//{
//	int i = 0;
//
//	for (i = 0; i < r; i++)
//	{
//		int j = 0;
//
//		for (j = 0; j < 5; j++)
//		{
//			printf("%d ", arr[i][j]);
//		}
//		printf("\n");
//	}
//}

//void test(int(*arr)[5], int r, int c)//注意不是int(*arr)[3][5]
//{
//	int i = 0;
//
//	for (i = 0; i < r; i++)
//	{
//		int j = 0;
//
//		for (j = 0; j < c; j++)
//		{
//			//*(arr+i) == arr[i]，arr指的是首元素地址
//			//printf("%d ", *(*(*arr + i) + j));//指针解引用找到这个地址，我写的//error
//			
//
//			//printf("%d ", *(*(arr + i) + j));
//			//printf("%d ", arr[i][j]);
//			//printf("%d ", (*(arr + i))[j]);
//
//			//就这样
//		}
//		printf("\n");
//	}
//}

//int main()
//{
//	int arr[3][5] = { { 1, 2, 3, 4, 5 }, { 2, 3, 4, 5, 6 }, { 3, 4, 5, 6, 7 } };
//	test(arr, 3, 5);
//
//
//	return 0;
//}


//2024-1-21 Sunday 10:07:30
//第13讲：深⼊理解指针(3)
//⽬录
//1. 字符指针变量
//2. 数组指针变量
//3. ⼆维数组传参的本质
//4. 函数指针变量
//5. 函数指针数组
//6. 转移表

//4. 函数指针变量
//4.1 函数指针变量的创建
//#include <stdio.h>
//
//int Add(int x, int y)
//{
//	return x + y;
//}
//
//int main()
//{
//	//数组名 - 数组首元素的地址
//	//&数组名 - 数组的地址
//	
//	//对于函数，&函数名和函数名都是函数的地址
//
//	printf("%p\n", &Add);
//	printf("%p\n", Add);
//
//	int* p1 = &Add;
//	int* p2 = Add;
//
//	return 0;
//}


//4.2 函数指针变量的使⽤
//#include <stdio.h>
//
//int Add(int x, int y)
//{
//	return x + y;
//}
//
//int main()
//{
//	int(*pf)(int, int) = &Add;
//	int(*pf2)(int, int) = Add;
//	//函数指针变量
//
//	int r = (*pf)(1, 2);//*pf通过地址找到指向的函数，传参过去调用
//	int r2 = pf2(3, 4);
//	int r3 = (&Add)(5, 6);//(&Add)，不然的话因为Add可以直接调，然后又&返回值了
//	int r4 = Add(7, 8);
//
//
//	printf("r  = %d\n", r);
//	printf("r2 = %d\n", r2);
//	printf("r3  = %d\n", r3);
//	printf("r4  = %d\n", r4);
//
//	return 0;
//}


//4.3 两段有趣的代码
//int main()
//{
//	//void(*)() - 函数指针类型
//	//(void(*)()) - (类型)强制类型转换
//	//(void (*)()) 0 - 把0(0x0012ff40 - int)给强制类型转换为函数指针类型
//	//0是一个地址，类型是int*，但是编译器以16进制显示
//	//(int*) - 0x0012ff40
//	//Add - 0x0012ff40
//	//    - 0
//
//	(*(void (*)()) 0)();
//	((void (*)()) 0)();//可以不加*，因为函数的地址也可以直接调用
//
//	//我的理解：0被强转为函数指针类型，说明0指向的是一个函数
//	 
//	//调用0地址处的函数，调用的函数，函数是无参的，返回值是void//为什么返回值是void?你是不是看错了？
//
//	return 0;
//}



















































//2024-1-20 Saturday 14:33:14
//随写
//#include <stdio.h>
//#pragma warning(disable : 4996)
//
//int main()
//{
//	int n = 0;
//	scanf("%d", &n);
//
//	while (n > 0)
//	{
//		printf("*");
//		n--;
//	}
//	printf("\n");
//
//	return 0;
//}


//2024-1-21 Sunday 15:49:44
//课上评论区的问题
int Add(int x, int y)
{
	return x + y;
}

int main()
{
	int(*parr[])(int, int) = { Add };
	//函数指针数组的指针
	int(*(*p)[1])(int, int) = &parr;

	return 0;
}
















 








